home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / shadez.swf / scripts / STC9 / IO / CKeyboard.as < prev   
Text File  |  2011-08-19  |  36KB  |  617 lines
  1. package STC9.IO
  2. {
  3.    import flash.display.InteractiveObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.KeyboardEvent;
  7.    
  8.    public class CKeyboard extends EventDispatcher
  9.    {
  10.       
  11.       public static var mKeyIDs:Array;
  12.       
  13.       public static var mLastKeyCodes:Array;
  14.       
  15.       public static var mMonitorItems:Object;
  16.       
  17.       public static var mItems:Array;
  18.       
  19.       public static const KEYDOWN:String = "KEYDOWN";
  20.       
  21.       public static var mKeycodeDown:int;
  22.       
  23.       public static var mKeyNameToKeyID:Object;
  24.       
  25.       public static var mActive:Boolean = false;
  26.       
  27.       public static var mKeyNames:Array;
  28.       
  29.       public static var mKeyTable:Object;
  30.       
  31.       {
  32.          if(true)
  33.          {
  34.             KEYDOWN = "KEYDOWN";
  35.             mActive = false;
  36.          }
  37.       }
  38.       
  39.       private var mDispatchEvents:Boolean;
  40.       
  41.       private var mFocusObject:InteractiveObject;
  42.       
  43.       public function CKeyboard(param1:InteractiveObject, param2:Boolean = false)
  44.       {
  45.          if(true)
  46.          {
  47.             super();
  48.             if(true)
  49.             {
  50.                mDispatchEvents = param2;
  51.                if(true)
  52.                {
  53.                   mFocusObject = param1;
  54.                   if(true)
  55.                   {
  56.                      mMonitorItems = new Object();
  57.                      if(true)
  58.                      {
  59.                         mLastKeyCodes = new Array();
  60.                         if(true)
  61.                         {
  62.                            if(mActive)
  63.                            {
  64.                               if(true)
  65.                               {
  66.                                  if(!mFocusObject.hasEventListener(KeyboardEvent.KEY_DOWN))
  67.                                  {
  68.                                  }
  69.                               }
  70.                            }
  71.                            mFocusObject.addEventListener(KeyboardEvent.KEY_DOWN,reportKeyDown);
  72.                         }
  73.                         mFocusObject.addEventListener(KeyboardEvent.KEY_UP,reportKeyUp);
  74.                      }
  75.                      mFocusObject.addEventListener(Event.DEACTIVATE,e_DEACTIVATE);
  76.                   }
  77.                   mFocusObject.addEventListener(Event.ACTIVATE,e_ACTIVATE);
  78.                }
  79.                SetupKeyTables();
  80.             }
  81.             mActive = true;
  82.          }
  83.       }
  84.       
  85.       private static function GetKeyCode(param1:*) : int
  86.       {
  87.          if(typeof param1 == "string")
  88.          {
  89.             return mKeyTable[param1];
  90.          }
  91.          return param1;
  92.       }
  93.       
  94.       public static function IsDown(param1:*) : Boolean
  95.       {
  96.          return mItems[GetKeyCode(param1)].mDown;
  97.       }
  98.       
  99.       public static function IsReleased(param1:*) : int
  100.       {
  101.          var _loc2_:Number = NaN;
  102.          if(true)
  103.          {
  104.             _loc2_ = mItems[GetKeyCode(param1)].mReleased;
  105.             mItems[GetKeyCode(param1)].mReleased = 0;
  106.          }
  107.          return _loc2_;
  108.       }
  109.       
  110.       public static function IsDownAuto(param1:*) : Number
  111.       {
  112.          var _loc2_:Number = NaN;
  113.          _loc2_ = mItems[GetKeyCode(param1)].mDownAuto;
  114.          mItems[GetKeyCode(param1)].mDownAuto = 0;
  115.          return _loc2_;
  116.       }
  117.       
  118.       public static function CompareString(param1:String) : Boolean
  119.       {
  120.          var _loc2_:* = null;
  121.          var _loc3_:Number = NaN;
  122.          var _loc4_:int = 0;
  123.          if(mLastKeyCodes.length < param1.length + 1)
  124.          {
  125.             return false;
  126.          }
  127.          _loc2_ = param1;
  128.          _loc3_ = mLastKeyCodes.length - (param1.length + 1);
  129.          for each(_loc4_ in mLastKeyCodes.slice(_loc3_,_loc3_ + param1.length))
  130.          {
  131.             if(GetKeyCode(_loc2_.charAt(0)) != _loc4_)
  132.             {
  133.                return false;
  134.             }
  135.             ┬º┬ºpush(_loc2_);
  136.             if(true)
  137.             {
  138.                ┬º┬ºpush(┬º┬ºpop().slice(1));
  139.             }
  140.             _loc2_ = ┬º┬ºpop();
  141.          }
  142.          return true;
  143.       }
  144.       
  145.       public static function IsPressed(param1:*) : int
  146.       {
  147.          var _loc2_:* = 0;
  148.          var _loc3_:CKey = null;
  149.          var _loc4_:Number = NaN;
  150.          ┬º┬ºpush(GetKeyCode(param1));
  151.          if(true)
  152.          {
  153.             ┬º┬ºpush(int(┬º┬ºpop()));
  154.          }
  155.          _loc2_ = ┬º┬ºpop();
  156.          _loc3_ = mItems[_loc2_];
  157.          _loc4_ = mItems[_loc2_].mPressed;
  158.          mItems[_loc2_].mPressed = 0;
  159.          return _loc4_;
  160.       }
  161.       
  162.       private function reportKeyDown(param1:KeyboardEvent) : void
  163.       {
  164.          if(true)
  165.          {
  166.             if(mItems[param1.keyCode])
  167.             {
  168.                if(true)
  169.                {
  170.                   mMonitorItems["key" + param1.keyCode] = mItems[param1.keyCode];
  171.                   if(true)
  172.                   {
  173.                      mItems[param1.keyCode].RegisterAsDown();
  174.                      mKeycodeDown = param1.keyCode;
  175.                   }
  176.                   if(!mDispatchEvents)
  177.                   {
  178.                   }
  179.                   ┬º┬ºgoto(addr60);
  180.                }
  181.                dispatchEvent(new Event(KEYDOWN));
  182.             }
  183.          }
  184.          addr60:
  185.       }
  186.       
  187.       private function SetupKeyTables() : void
  188.       {
  189.          var _loc1_:* = 0;
  190.          var _loc2_:* = null;
  191.          if(true)
  192.          {
  193.             mKeyTable = new Object();
  194.             _loc1_ = 65;
  195.          }
  196.          loop0:
  197.          while(true)
  198.          {
  199.             ┬º┬ºpush(_loc1_);
  200.             if(true)
  201.             {
  202.                ┬º┬ºpush(65);
  203.                if(true)
  204.                {
  205.                   ┬º┬ºpush(┬º┬ºpop() + 26);
  206.                   if(true)
  207.                   {
  208.                      if(┬º┬ºpop() >= ┬º┬ºpop())
  209.                      {
  210.                         if(true)
  211.                         {
  212.                            ┬º┬ºpush(48);
  213.                            if(true)
  214.                            {
  215.                               _loc1_ = ┬º┬ºpop();
  216.                               if(true)
  217.                               {
  218.                                  loop1:
  219.                                  while(true)
  220.                                  {
  221.                                     ┬º┬ºpush(_loc1_);
  222.                                     if(true)
  223.                                     {
  224.                                        ┬º┬ºpush(48);
  225.                                        if(true)
  226.                                        {
  227.                                           ┬º┬ºpush(┬º┬ºpop() + 10);
  228.                                           loop12:
  229.                                           while(true)
  230.                                           {
  231.                                              if(┬º┬ºpop() < ┬º┬ºpop())
  232.                                              {
  233.                                                 mKeyTable[String.fromCharCode(_loc1_)] = _loc1_;
  234.                                                 if(true)
  235.                                                 {
  236.                                                    _loc1_++;
  237.                                                    if(true)
  238.                                                    {
  239.                                                       continue loop1;
  240.                                                    }
  241.                                                    addr444:
  242.                                                    addr455:
  243.                                                    while(true)
  244.                                                    {
  245.                                                       ┬º┬ºpush(_loc1_);
  246.                                                       addr456:
  247.                                                       addr458:
  248.                                                       addr462:
  249.                                                       loop8:
  250.                                                       while(true)
  251.                                                       {
  252.                                                          ┬º┬ºpush(256);
  253.                                                          addr457:
  254.                                                          while(true)
  255.                                                          {
  256.                                                             if(┬º┬ºpop() >= ┬º┬ºpop())
  257.                                                             {
  258.                                                                break loop8;
  259.                                                             }
  260.                                                             addr445:
  261.                                                             mKeyNames[_loc1_] = "";
  262.                                                             break loop12;
  263.                                                          }
  264.                                                       }
  265.                                                       mKeyNameToKeyID = new Object();
  266.                                                       break loop0;
  267.                                                    }
  268.                                                 }
  269.                                                 break;
  270.                                              }
  271.                                              if(true)
  272.                                              {
  273.                                                 mKeyTable["F1"] = 112;
  274.                                                 if(true)
  275.                                                 {
  276.                                                    mKeyTable["F2"] = 113;
  277.                                                    if(true)
  278.                                                    {
  279.                                                       mKeyTable["F3"] = 114;
  280.                                                       if(true)
  281.                                                       {
  282.                                                          mKeyTable["F4"] = 115;
  283.                                                          if(true)
  284.                                                          {
  285.                                                             mKeyTable["F5"] = 116;
  286.                                                             if(true)
  287.                                                             {
  288.                                                                mKeyTable["F6"] = 117;
  289.                                                                if(true)
  290.                                                                {
  291.                                                                   mKeyTable["F7"] = 118;
  292.                                                                   if(true)
  293.                                                                   {
  294.                                                                      mKeyTable["F8"] = 119;
  295.                                                                      if(true)
  296.                                                                      {
  297.                                                                         mKeyTable["F9"] = 120;
  298.                                                                         if(true)
  299.                                                                         {
  300.                                                                            mKeyTable["F10"] = 121;
  301.                                                                            if(true)
  302.                                                                            {
  303.                                                                               mKeyTable["F11"] = 122;
  304.                                                                               if(true)
  305.                                                                               {
  306.                                                                                  mKeyTable["F12"] = 123;
  307.                                                                                  if(true)
  308.                                                                                  {
  309.                                                                                     mKeyTable["F13"] = 124;
  310.                                                                                     if(true)
  311.                                                                                     {
  312.                                                                                        mKeyTable["F14"] = 125;
  313.                                                                                        if(true)
  314.                                                                                        {
  315.                                                                                           mKeyTable["F15"] = 126;
  316.                                                                                           if(true)
  317.                                                                                           {
  318.                                                                                              mKeyTable["NUM_LOCK"] = 144;
  319.                                                                                              if(true)
  320.                                                                                              {
  321.                                                                                                 mKeyTable["SCR_LOCK"] = 145;
  322.                                                                                                 if(true)
  323.                                                                                                 {
  324.                                                                                                    mKeyTable["PAUSE"] = 19;
  325.                                                                                                    if(true)
  326.                                                                                                    {
  327.                                                                                                       mKeyTable["NUMPAD_0"] = 96;
  328.                                                                                                       if(true)
  329.                                                                                                       {
  330.                                                                                                          mKeyTable["NUMPAD_1"] = 97;
  331.                                                                                                          if(true)
  332.                                                                                                          {
  333.                                                                                                             mKeyTable["NUMPAD_2"] = 98;
  334.                                                                                                             if(true)
  335.                                                                                                             {
  336.                                                                                                                mKeyTable["NUMPAD_3"] = 99;
  337.                                                                                                                if(true)
  338.                                                                                                                {
  339.                                                                                                                   mKeyTable["NUMPAD_4"] = 100;
  340.                                                                                                                   if(true)
  341.                                                                                                                   {
  342.                                                                                                                      mKeyTable["NUMPAD_5"] = 101;
  343.                                                                                                                      if(true)
  344.                                                                                                                      {
  345.                                                                                                                         mKeyTable["NUMPAD_6"] = 102;
  346.                                                                                                                         if(true)
  347.                                                                                                                         {
  348.                                                                                                                            mKeyTable["NUMPAD_7"] = 103;
  349.                                                                                                                            if(true)
  350.                                                                                                                            {
  351.                                                                                                                               mKeyTable["NUMPAD_8"] = 104;
  352.                                                                                                                               if(true)
  353.                                                                                                                               {
  354.                                                                                                                                  mKeyTable["NUMPAD_9"] = 105;
  355.                                                                                                                                  if(true)
  356.                                                                                                                                  {
  357.                                                                                                                                     mKeyTable["NUMPAD_ADD"] = 107;
  358.                                                                                                                                     if(true)
  359.                                                                                                                                     {
  360.                                                                                                                                        mKeyTable["NUMPAD_DECIMAL"] = 110;
  361.                                                                                                                                        if(true)
  362.                                                                                                                                        {
  363.                                                                                                                                           mKeyTable["NUMPAD_DIVIDE"] = 111;
  364.                                                                                                                                           if(true)
  365.                                                                                                                                           {
  366.                                                                                                                                              mKeyTable["NUMPAD_ENTER"] = 108;
  367.                                                                                                                                              if(true)
  368.                                                                                                                                              {
  369.                                                                                                                                                 mKeyTable["NUMPAD_MULTIPLY"] = 106;
  370.                                                                                                                                                 if(true)
  371.                                                                                                                                                 {
  372.                                                                                                                                                    mKeyTable["NUMPAD_SUBTRACT"] = 109;
  373.                                                                                                                                                    if(true)
  374.                                                                                                                                                    {
  375.                                                                                                                                                       mKeyTable["COLON"] = 186;
  376.                                                                                                                                                       mKeyTable["EQUALS"] = 187;
  377.                                                                                                                                                    }
  378.                                                                                                                                                    mKeyTable["MINUS"] = 189;
  379.                                                                                                                                                 }
  380.                                                                                                                                                 mKeyTable["FWD_SLASH"] = 191;
  381.                                                                                                                                              }
  382.                                                                                                                                              mKeyTable["LSQR_BRACKET"] = 219;
  383.                                                                                                                                           }
  384.                                                                                                                                           mKeyTable["RSQR_BRACKET"] = 221;
  385.                                                                                                                                        }
  386.                                                                                                                                        mKeyTable["BACK_SLASH"] = 220;
  387.                                                                                                                                     }
  388.                                                                                                                                     mKeyTable["COMMA"] = 188;
  389.                                                                                                                                  }
  390.                                                                                                                                  mKeyTable["DOT"] = 190;
  391.                                                                                                                               }
  392.                                                                                                                               mKeyTable["HOME"] = 36;
  393.                                                                                                                            }
  394.                                                                                                                            mKeyTable["INSERT"] = 45;
  395.                                                                                                                         }
  396.                                                                                                                         mKeyTable["PAGE_DOWN"] = 34;
  397.                                                                                                                      }
  398.                                                                                                                      mKeyTable["PAGE_UP"] = 33;
  399.                                                                                                                   }
  400.                                                                                                                   mKeyTable["SHIFT"] = 16;
  401.                                                                                                                }
  402.                                                                                                                mKeyTable["SPACE"] = 32;
  403.                                                                                                             }
  404.                                                                                                             mKeyTable["TAB"] = 9;
  405.                                                                                                          }
  406.                                                                                                          mKeyTable["QUOTE"] = 34;
  407.                                                                                                       }
  408.                                                                                                       mKeyTable["BACKSPACE"] = 8;
  409.                                                                                                    }
  410.                                                                                                    mKeyTable["CAPS_LOCK"] = 20;
  411.                                                                                                 }
  412.                                                                                                 mKeyTable["CONTROL"] = 17;
  413.                                                                                              }
  414.                                                                                              mKeyTable["DELETE"] = 46;
  415.                                                                                           }
  416.                                                                                           mKeyTable["END"] = 35;
  417.                                                                                        }
  418.                                                                                        mKeyTable["ENTER"] = 13;
  419.                                                                                     }
  420.                                                                                     mKeyTable["RETURN"] = 13;
  421.                                                                                  }
  422.                                                                                  mKeyTable["ESCAPE"] = 27;
  423.                                                                               }
  424.                                                                               mKeyTable["UP"] = 38;
  425.                                                                            }
  426.                                                                            mKeyTable["LEFT"] = 37;
  427.                                                                         }
  428.                                                                         mKeyTable["DOWN"] = 40;
  429.                                                                      }
  430.                                                                      mKeyTable["RIGHT"] = 39;
  431.                                                                   }
  432.                                                                   mItems = new Array();
  433.                                                                }
  434.                                                                ┬º┬ºpush(0);
  435.                                                                if(true)
  436.                                                                {
  437.                                                                   _loc1_ = ┬º┬ºpop();
  438.                                                                   addr423:
  439.                                                                   while(true)
  440.                                                                   {
  441.                                                                      ┬º┬ºpush(_loc1_);
  442.                                                                   }
  443.                                                                   addr431:
  444.                                                                }
  445.                                                                loop4:
  446.                                                                while(true)
  447.                                                                {
  448.                                                                   ┬º┬ºpush(256);
  449.                                                                   addr433:
  450.                                                                   while(┬º┬ºpop() < ┬º┬ºpop())
  451.                                                                   {
  452.                                                                      mItems.push(new CKey(_loc1_));
  453.                                                                      while(true)
  454.                                                                      {
  455.                                                                         _loc1_++;
  456.                                                                         ┬º┬ºgoto(addr431);
  457.                                                                      }
  458.                                                                      continue loop4;
  459.                                                                   }
  460.                                                                   addr434:
  461.                                                                   addr438:
  462.                                                                   addr442:
  463.                                                                   mKeyNames = new Array();
  464.                                                                   mKeyIDs = new Array();
  465.                                                                   break loop1;
  466.                                                                }
  467.                                                             }
  468.                                                             ┬º┬ºgoto(addr423);
  469.                                                          }
  470.                                                          ┬º┬ºgoto(addr430);
  471.                                                       }
  472.                                                       ┬º┬ºgoto(addr423);
  473.                                                    }
  474.                                                    ┬º┬ºgoto(addr434);
  475.                                                 }
  476.                                                 ┬º┬ºgoto(addr438);
  477.                                              }
  478.                                              ┬º┬ºgoto(addr442);
  479.                                           }
  480.                                           loop3:
  481.                                           while(true)
  482.                                           {
  483.                                              mKeyIDs[_loc1_] = "";
  484.                                              addr454:
  485.                                              while(true)
  486.                                              {
  487.                                                 _loc1_++;
  488.                                                 ┬º┬ºgoto(addr455);
  489.                                                 continue loop3;
  490.                                              }
  491.                                           }
  492.                                           addr85:
  493.                                        }
  494.                                        ┬º┬ºgoto(addr433);
  495.                                     }
  496.                                     break;
  497.                                  }
  498.                                  _loc1_ = ┬º┬ºpop();
  499.                                  ┬º┬ºgoto(addr444);
  500.                               }
  501.                               ┬º┬ºgoto(addr454);
  502.                            }
  503.                            ┬º┬ºgoto(addr456);
  504.                         }
  505.                         ┬º┬ºgoto(addr444);
  506.                      }
  507.                      else
  508.                      {
  509.                         mKeyTable[String.fromCharCode(_loc1_)] = _loc1_;
  510.                         if(true)
  511.                         {
  512.                            mKeyTable[String.fromCharCode(_loc1_ + 32)] = _loc1_;
  513.                            if(true)
  514.                            {
  515.                               _loc1_++;
  516.                               if(true)
  517.                               {
  518.                                  continue;
  519.                               }
  520.                               ┬º┬ºgoto(addr458);
  521.                            }
  522.                            ┬º┬ºgoto(addr462);
  523.                         }
  524.                         ┬º┬ºgoto(addr507);
  525.                      }
  526.                   }
  527.                   ┬º┬ºgoto(addr85);
  528.                }
  529.                ┬º┬ºgoto(addr457);
  530.             }
  531.             break;
  532.          }
  533.          for(_loc2_ in mKeyTable)
  534.          {
  535.             mKeyNames[mKeyTable[_loc2_]] = TReplace(_loc2_);
  536.             mKeyNameToKeyID[mKeyNames[mKeyTable[_loc2_]]] = _loc2_;
  537.             mKeyIDs[mKeyTable[_loc2_]] = _loc2_;
  538.          }
  539.          addr507:
  540.       }
  541.       
  542.       private function e_DEACTIVATE(param1:Event) : void
  543.       {
  544.          var _loc2_:CKey = null;
  545.          for each(_loc2_ in mMonitorItems)
  546.          {
  547.             _loc2_.Clear();
  548.          }
  549.          mMonitorItems = new Object();
  550.       }
  551.       
  552.       private function reportKeyUp(param1:KeyboardEvent) : void
  553.       {
  554.          if(mLastKeyCodes.push(param1.keyCode) > 20)
  555.          {
  556.             mLastKeyCodes = mLastKeyCodes.slice(mLastKeyCodes.length - 20);
  557.          }
  558.          if(mItems[param1.keyCode])
  559.          {
  560.             delete mMonitorItems["key" + param1.keyCode];
  561.             mItems[param1.keyCode].RegisterAsUp();
  562.          }
  563.       }
  564.       
  565.       private function e_ACTIVATE(param1:Event) : void
  566.       {
  567.       }
  568.       
  569.       public function get _CLASSID_() : String
  570.       {
  571.          return "CKeyboard";
  572.       }
  573.       
  574.       override public function toString() : String
  575.       {
  576.          return _CLASSID_;
  577.       }
  578.       
  579.       public function Clear() : void
  580.       {
  581.          var _loc1_:CKey = null;
  582.          for each(_loc1_ in mItems)
  583.          {
  584.             _loc1_.Clear();
  585.          }
  586.          mLastKeyCodes = new Array();
  587.       }
  588.       
  589.       private function TReplace(param1:String) : String
  590.       {
  591.          var _loc2_:RegExp = null;
  592.          _loc2_ = /_/;
  593.          ┬º┬ºpush(param1);
  594.          if(true)
  595.          {
  596.             param1 = ┬º┬ºpop().replace(_loc2_," ").toLowerCase();
  597.             ┬º┬ºpush(param1);
  598.          }
  599.          return ┬º┬ºpop();
  600.       }
  601.       
  602.       public function get _BASECLASSID_() : String
  603.       {
  604.          return "CKeyboard";
  605.       }
  606.       
  607.       public function Dispose() : void
  608.       {
  609.          mFocusObject.removeEventListener(KeyboardEvent.KEY_DOWN,reportKeyDown);
  610.          mFocusObject.removeEventListener(KeyboardEvent.KEY_UP,reportKeyUp);
  611.          mFocusObject.removeEventListener(Event.DEACTIVATE,e_DEACTIVATE);
  612.          mFocusObject.removeEventListener(Event.ACTIVATE,e_ACTIVATE);
  613.          mActive = false;
  614.       }
  615.    }
  616. }
  617.